{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Add my QComponent to a reusable python file\n",
    "\n",
    "### Preparations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preload python packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "import qiskit_metal as metal\n",
    "from qiskit_metal import designs, draw\n",
    "from qiskit_metal import MetalGUI, Dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a design and open the GUI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "design = designs.DesignPlanar()\n",
    "design.overwrite_enabled = True\n",
    "gui = MetalGUI(design)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managing a QComponent\n",
    "#### Create an instance\n",
    "Create an instance of `TransmonPocket`. Notice the import needs to use the absolute path. This is to minimize the dynamic memory footprint of Qiskit Metal and to prevent QComponent sub-class naming conflicts that might occur if user creates custom ones.\n",
    "\n",
    "Observe how, at time of creation, we define some basic options of the TransmonPocket, being the number/name of connection pads(`a`->`d`). Most options can be defined/updated also after the creation of the QComponent instance, as we will show later in this section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_metal.qlibrary.qubits.transmon_pocket import TransmonPocket\n",
    "\n",
    "q1options = dict(\n",
    "    connection_pads=dict(  # pin connectors\n",
    "        a = dict(loc_W=+1,loc_H=+1), \n",
    "        b = dict(loc_W=-1,loc_H=+1),\n",
    "        c = dict(loc_W=+1,loc_H=-1),\n",
    "        d = dict(loc_W=-1,loc_H=-1)\n",
    "    )\n",
    ")\n",
    "\n",
    "q1 = TransmonPocket(design, options = q1options)  # this line only creates the object in memory and executes its __init__(), but does not \"implement\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turn your attention to the Qiskit Metal GUI. In the `Main View` tab you will not see `q1` yet. However if you open the tab `Elements`, you will observe that all of its shapes (`component_id` = 1) are now present in the QGeometry tables (show in that tab). This occurs because the `__init__()` of the QComponent class already run the `make()` of the TransmonPocket.\n",
    "\n",
    "Note that the `make()` if the component does not automatically render to the GUI, for increased usage flexibility. Therefore we need to explicit call the method `gui.rebuild()` to observe the shapes in the `Main View`. We do that in the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "gui.rebuild()  # this updates the QComponent tables by running make()\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Controlling the instance using its interface parameters\n",
    "\n",
    "Now we can also change the options of the component `q1` before we re-run the make.\n",
    "\n",
    "QComponent classes can have parameterized `make()`. That means that the final shapes will be the result of a combination of input parameters. Said parameters and their defaults are described in the QComponent `default_options`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'chip': 'main',\n",
       " 'pos_x': '0um',\n",
       " 'pos_y': '0um',\n",
       " 'pad_gap': '30um',\n",
       " 'inductor_width': '20um',\n",
       " 'pad_width': '455um',\n",
       " 'pad_height': '90um',\n",
       " 'pocket_width': '650um',\n",
       " 'pocket_height': '650um',\n",
       " 'orientation': '0',\n",
       " '_default_connection_pads': {'pad_gap': '15um',\n",
       "  'pad_width': '125um',\n",
       "  'pad_height': '30um',\n",
       "  'pad_cpw_shift': '5um',\n",
       "  'pad_cpw_extent': '25um',\n",
       "  'cpw_width': 'cpw_width',\n",
       "  'cpw_gap': 'cpw_gap',\n",
       "  'cpw_extend': '100um',\n",
       "  'pocket_extent': '5um',\n",
       "  'pocket_rise': '65um',\n",
       "  'loc_W': '+1',\n",
       "  'loc_H': '+1'}}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q1.default_options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This list of options is also \"extended\" by the supported renderers. This is because the simulation/analysis can have shape- (or even QComponent-)dependent parameters to e set. See below the full list of options available for the user to update for the `TransmonPocket`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'pos_x': '0um',\n",
       " 'pos_y': '0um',\n",
       " 'connection_pads': {'a': {'pad_gap': '15um',\n",
       "   'pad_width': '125um',\n",
       "   'pad_height': '30um',\n",
       "   'pad_cpw_shift': '5um',\n",
       "   'pad_cpw_extent': '25um',\n",
       "   'cpw_width': 'cpw_width',\n",
       "   'cpw_gap': 'cpw_gap',\n",
       "   'cpw_extend': '100um',\n",
       "   'pocket_extent': '5um',\n",
       "   'pocket_rise': '65um',\n",
       "   'loc_W': 1,\n",
       "   'loc_H': 1},\n",
       "  'b': {'pad_gap': '15um',\n",
       "   'pad_width': '125um',\n",
       "   'pad_height': '30um',\n",
       "   'pad_cpw_shift': '5um',\n",
       "   'pad_cpw_extent': '25um',\n",
       "   'cpw_width': 'cpw_width',\n",
       "   'cpw_gap': 'cpw_gap',\n",
       "   'cpw_extend': '100um',\n",
       "   'pocket_extent': '5um',\n",
       "   'pocket_rise': '65um',\n",
       "   'loc_W': -1,\n",
       "   'loc_H': 1},\n",
       "  'c': {'pad_gap': '15um',\n",
       "   'pad_width': '125um',\n",
       "   'pad_height': '30um',\n",
       "   'pad_cpw_shift': '5um',\n",
       "   'pad_cpw_extent': '25um',\n",
       "   'cpw_width': 'cpw_width',\n",
       "   'cpw_gap': 'cpw_gap',\n",
       "   'cpw_extend': '100um',\n",
       "   'pocket_extent': '5um',\n",
       "   'pocket_rise': '65um',\n",
       "   'loc_W': 1,\n",
       "   'loc_H': -1},\n",
       "  'd': {'pad_gap': '15um',\n",
       "   'pad_width': '125um',\n",
       "   'pad_height': '30um',\n",
       "   'pad_cpw_shift': '5um',\n",
       "   'pad_cpw_extent': '25um',\n",
       "   'cpw_width': 'cpw_width',\n",
       "   'cpw_gap': 'cpw_gap',\n",
       "   'cpw_extend': '100um',\n",
       "   'pocket_extent': '5um',\n",
       "   'pocket_rise': '65um',\n",
       "   'loc_W': -1,\n",
       "   'loc_H': -1}},\n",
       " 'chip': 'main',\n",
       " 'pad_gap': '30um',\n",
       " 'inductor_width': '20um',\n",
       " 'pad_width': '455um',\n",
       " 'pad_height': '90um',\n",
       " 'pocket_width': '650um',\n",
       " 'pocket_height': '650um',\n",
       " 'orientation': '0',\n",
       " 'hfss_wire_bonds': False,\n",
       " 'q3d_wire_bonds': False,\n",
       " 'hfss_inductance': '10nH',\n",
       " 'hfss_capacitance': 0,\n",
       " 'hfss_resistance': 0,\n",
       " 'hfss_mesh_kw_jj': 7e-06,\n",
       " 'q3d_inductance': '10nH',\n",
       " 'q3d_capacitance': 0,\n",
       " 'q3d_resistance': 0,\n",
       " 'q3d_mesh_kw_jj': 7e-06,\n",
       " 'gds_cell_name': 'my_other_junction'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q1.options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These options can be modified at creation, using the `options` parameter of the QComponent init method. See `q1options` in the above cells. Later i this notebook, we will show how to update options at a later time (After creation).\n",
    "\n",
    "#### QComponent name changes\n",
    "The previously created TransmonPocket instance, was named `Pocket_1` by default (see in GUI or by executing `q1.name`). The first part of the name is defined in the QComponent class `component_metadata -> short name` as we will see later, while the suffix is an incremental integer resulting from a QComponent class-specific counter.\n",
    "\n",
    "Instead of using the default name, we can assign the QComponent instance name at creation, for example: `q1 = TransmonPocket(design, name = \"Q1\", options = q1options)`. We can also rename it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "design.rename_component(q1.id,'Q1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Connecting two QComponents - Nets\n",
    "Let's demonstrate how to update the options of a component after creation by updating `pos_x` to move `Q1` towards the left. let's go ahead and create also an identical TransmonPocket (`Q2`) to its right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "q1.options.pos_x='-1.5mm'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "q2 = design.copy_qcomponent(q1, 'Q2')\n",
    "q2.options.pos_x='1.5mm'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To connect `Q1:a` to `Q2:b`, we will use a QComponent that inherits from the `QRoute` class. In this example, we use `RouteMeander`.\n",
    "\n",
    "Note that it is mandatory to provide the option `pin_inputs` for a QRoute to be created correctly. Indeed a QRoute generates its own pins by mirroring the pins of the QComponents it needs to connect.\n",
    "For `RouteMeander`, we also need to provide a `total_length`, since the meander shapes will be created to match the target transmission line length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_metal.qlibrary.tlines.meandered import RouteMeander\n",
    "\n",
    "options = Dict(\n",
    "    total_length = '8mm',\n",
    "    pin_inputs = Dict(\n",
    "        start_pin = Dict(\n",
    "            component = 'Q1',\n",
    "            pin = 'a'),\n",
    "        end_pin = Dict(\n",
    "            component = 'Q2',\n",
    "            pin = 'b')),\n",
    ")\n",
    "\n",
    "cpw = RouteMeander(design, options=options)\n",
    "gui.rebuild()\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The meander was created without corner rounding because the fillet radius was not specified. Let's go ahead and update the RouteMeander instance to smooth out those edges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "cpw.options.fillet = '90um'\n",
    "cpw.options.lead.start_straight = '90um'\n",
    "\n",
    "gui.rebuild()\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, observe how the `net_info` table has been updated to record the physical/electrical connection between the two TransmonPocket instances and the RouteMeander instance. Two nets were created connecting the 4 involved pins in pairs (2 pins of the RouteMenader instance and two pins one each Transmon Pocket instance).\n",
    "\n",
    "Nets always pair pins. Net can never connect more than 2 pins because every net represents a point contact between two QComponents. This could appear like an excessive constrain when compared to net definition in traditional circuit design. However, it helps normalize the quantum circuit design flow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>net_id</th>\n",
       "      <th>component_id</th>\n",
       "      <th>pin_name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>a</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>start</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>b</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>6</td>\n",
       "      <td>3</td>\n",
       "      <td>end</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  net_id component_id pin_name\n",
       "0      5            1        a\n",
       "1      5            3    start\n",
       "2      6            2        b\n",
       "3      6            3      end"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "design.net_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a custom component from scratch\n",
    "#### The QComponent blueprint\n",
    "```\n",
    "class SomeComponent(QComponent):\n",
    "    default_options = Dict(…)\n",
    "    def make(self):\n",
    "        ...\n",
    "        self.add_qgeometry(…)\n",
    "        self.add_pin(…)\n",
    "```\n",
    "`SomeComponent` = The name of the new QComponent class, which should alway inherit from `QComponent`.<br>\n",
    "`default_options` = The interface for parameters that influence the shape generation of the `make()`.<br>\n",
    "`make()` = Math to generate the shapes implementing the QComponent instance.<br>\n",
    "`add_qgeometry()` = Method to create `path`, `poly` and `junction` in the QGeometry table.<br>\n",
    "`add_pin()` = Method to create the pins to connect the QComponent through QRoute components.\n",
    "\n",
    "#### Building from that blueprint\n",
    "First, let's free up space in the layout we just compoese in the previous section. Specifically let's eliminate the cpw and Q2 instances (We will reuse Q1).\n",
    "\n",
    "Note in the following cell I am intentionally using two different methods to delete a component, just to illustrate them. YOu can use only one of the two methods in your notebooks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "design.delete_component('Q2')\n",
    "cpw.delete()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the `net_info` table is now empty because we eliminated `cpw`, which was connecting the QComponent instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>net_id</th>\n",
       "      <th>component_id</th>\n",
       "      <th>pin_name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [net_id, component_id, pin_name]\n",
       "Index: []"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "design.net_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the remainder of this section, you will need the file `my429_qcomponent.py`, which contains incremantally complex examples of custom components, intended only for illustrative purposes.\n",
    "\n",
    "Your file `my429_qcomponents.py` could be a at a different location, so you might need to update appropriately the import in the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from qiskit_metal.qlibrary.user_components.my429_qcomponents import MyQComponent1\n",
    "import sys\n",
    "sys.path.append('../../resources')\n",
    "from my429_qcomponents import MyQComponent1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first class `MyQComponent1` has been designed to be as simple as possible. In fact, it is not even parameterized. It is a simple fixed-size rectangle with a pin on the left edge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "myQC = MyQComponent1(design, 'myQC')\n",
    "\n",
    "gui.rebuild()  # this is need to actually make() the component\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Open the `my429_qcomponents.py` file to observe the class code. You will notice it only calls the two key methods `add_qgeometry()` and `add_pins()`. It is that simple to create a custom QComponent, you just need 2 lines of code. With the following cell you can observe that the two lines are already sufficient to route to the QComponent and get its geometries inside the QGeometry table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = Dict(\n",
    "    total_length = '4mm',\n",
    "    pin_inputs = Dict(\n",
    "        start_pin = Dict(\n",
    "            component = 'Q1',\n",
    "            pin = 'a'),\n",
    "        end_pin = Dict(\n",
    "            component = myQC.name,\n",
    "            pin = 'in')),\n",
    "    fillet = '90um',\n",
    "    lead = Dict(\n",
    "        start_straight = '90um')\n",
    ")\n",
    "\n",
    "cpw = RouteMeander(design, options=options)\n",
    "gui.rebuild()\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The previous class example did not allow for parametrization. Let's introduce that factor with the next example class `MyQComponent2`. First observe the different shapes by running the following cell, and then compare the code by opening again the `my429_qcomponents.py` file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "cpw.delete()\n",
    "myQC.delete()\n",
    "\n",
    "# from qiskit_metal.qlibrary.user_components.my429_qcomponents import MyQComponent2\n",
    "from my429_qcomponents import MyQComponent2\n",
    "\n",
    "opt_myqc = Dict(width='1mm', height='0.01mm', pos_x='0.1mm')\n",
    "myQC = MyQComponent2(design, 'myQC', options=opt_myqc)\n",
    "\n",
    "cpw = RouteMeander(design, options=options)\n",
    "gui.rebuild()  # this is need to actually make() the component\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe the available options with the next cell. These are only the options we listed in the `default_options`, the renderers did not add any analysis-related option to the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'width': '1mm',\n",
       " 'height': '0.01mm',\n",
       " 'pos_x': '0.1mm',\n",
       " 'pos_y': '0mm',\n",
       " 'layer': '1'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myQC.options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason the list of `options` and `default_options` match is because the class was not designed to import the renderer-dependent options from the renderer. To do that you will need to add the `component_metadata` to your class. We do that in `MyQComponent3` and `MyQComponent4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "cpw.delete()\n",
    "myQC.delete()\n",
    "\n",
    "opt_myqc.gap = '8um'\n",
    "opt_myqc.height = '20um'\n",
    "# from qiskit_metal.qlibrary.user_components.my429_qcomponents import MyQComponent4\n",
    "from my429_qcomponents import MyQComponent4\n",
    "\n",
    "myQC = MyQComponent4(design, options=opt_myqc) #opt_myqc defined earlier\n",
    "\n",
    "options = Dict(\n",
    "    total_length = '4mm',\n",
    "    pin_inputs = Dict(\n",
    "        start_pin = Dict(\n",
    "            component = 'Q1',\n",
    "            pin = 'a'),\n",
    "        end_pin = Dict(\n",
    "            component = myQC.name, #updating this\n",
    "            pin = 'in')),\n",
    "    fillet = '90um',\n",
    "    lead = Dict(\n",
    "        start_straight = '90um')\n",
    ")\n",
    "\n",
    "cpw = RouteMeander(design, options=options)\n",
    "gui.rebuild()  # this is need to actually make() the component\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {
      "image/png": {
       "width": 500
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gui.screenshot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe the additional renderer parameters being added to the list of options that the user can modify."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'width': '1mm',\n",
       " 'height': '20um',\n",
       " 'gap': '8um',\n",
       " 'pos_x': '0.1mm',\n",
       " 'pos_y': '0mm',\n",
       " 'layer': '1',\n",
       " 'hfss_wire_bonds': False,\n",
       " 'q3d_wire_bonds': False}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myQC.options"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
